/**
 * 通用数据管理器
 * 提供用户信息、订单列表等数据的智能缓存管理
 * 基于现有的CacheManager，提供更高级的数据管理功能
 */

const cacheManager = require('./cache-manager.js');
const apiService = require('./api.js');
const auth = require('./auth.js');

class DataManager {
  constructor() {
    this.loadingPromises = new Map(); // 防止重复请求
    this.cacheConfig = {
      userProfile: { ttl: 10 * 60 * 1000, key: 'user_profile' }, // 用户信息缓存10分钟
      orderList: { ttl: 5 * 60 * 1000, key: 'order_list' }, // 订单列表缓存5分钟
      petList: { ttl: 15 * 60 * 1000, key: 'pet_list' }, // 宠物列表缓存15分钟
      couponList: { ttl: 8 * 60 * 1000, key: 'coupon_list' }, // 优惠券列表缓存8分钟
      tradingRecords: { ttl: 10 * 60 * 1000, key: 'trading_records' }, // 交易记录缓存10分钟
      userBalance: { ttl: 3 * 60 * 1000, key: 'user_balance' } // 用户余额缓存3分钟
    };
  }

  /**
   * 获取用户信息
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Object>} 用户信息
   */
  async getUserProfile(forceRefresh = false) {
    const config = this.cacheConfig.userProfile;
    const cacheKey = this._getUserCacheKey(config.key);
    
    // 检查缓存
    if (!forceRefresh) {
      const cached = cacheManager.get(cacheKey);
      if (cached) {
        console.log('[DataManager] 用户信息命中缓存');
        return cached;
      }
    }

    // 防止重复请求
    if (this.loadingPromises.has(cacheKey)) {
      return this.loadingPromises.get(cacheKey);
    }

    const loadPromise = this._loadUserProfile();
    this.loadingPromises.set(cacheKey, loadPromise);

    try {
      const result = await loadPromise;
      if (result) {
        console.log('[DataManager] 设置宠物列表缓存:');
        console.log('- cacheKey:', cacheKey);
        console.log('- 数据长度:', result.length);
        console.log('- TTL:', config.ttl);
        cacheManager.set(cacheKey, result, config.ttl);
        console.log('[DataManager] 宠物列表缓存设置完成');
      } else {
        console.log('[DataManager] 宠物列表数据为空，不设置缓存');
      }
      return result;
    } finally {
      this.loadingPromises.delete(cacheKey);
    }
  }

  /**
   * 获取订单列表
   * @param {Object} params 查询参数 {status, page, size}
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Object>} 订单列表
   */
  async getOrderList(params = {}, forceRefresh = false) {
    const config = this.cacheConfig.orderList;
    
    // 确保 params 是对象，且不包含 forceRefresh 等非查询参数
    const queryParams = {
      status: params.status !== undefined && typeof params.status === 'number' ? params.status : undefined,
      page: params.page || 1,
      size: params.size || 20
    };
    
    const cacheKey = this._getUserCacheKey(`${config.key}_${JSON.stringify(queryParams)}`);
    
    // 检查缓存
    if (!forceRefresh) {
      const cached = cacheManager.get(cacheKey);
      if (cached) {
        console.log('[DataManager] 订单列表命中缓存');
        return cached;
      }
    }

    // 防止重复请求
    if (this.loadingPromises.has(cacheKey)) {
      return this.loadingPromises.get(cacheKey);
    }

    const loadPromise = this._loadOrderList(queryParams);
    this.loadingPromises.set(cacheKey, loadPromise);

    try {
      const result = await loadPromise;
      if (result) {
        cacheManager.set(cacheKey, result, config.ttl);
      }
      return result;
    } finally {
      this.loadingPromises.delete(cacheKey);
    }
  }

  /**
   * 获取宠物列表
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Array>} 宠物列表
   */
  async getPetList(forceRefresh = false) {
    const config = this.cacheConfig.petList;
    const userId = wx.getStorageSync('userId');
    const cacheKey = this._getUserCacheKey(config.key);
    
    console.log('[DataManager] getPetList调试信息:');
    console.log('- forceRefresh:', forceRefresh);
    console.log('- userId:', userId);
    console.log('- baseKey:', config.key);
    console.log('- cacheKey:', cacheKey);
    
    // 强制刷新时，清除正在进行的请求和缓存
    if (forceRefresh) {
      console.log('[DataManager] 强制刷新，清除缓存和正在进行的请求');
      cacheManager.delete(cacheKey);
      if (this.loadingPromises.has(cacheKey)) {
        console.log('[DataManager] 清除正在进行的请求');
        this.loadingPromises.delete(cacheKey);
      }
    }
    
    // 检查缓存
    if (!forceRefresh) {
      const cached = cacheManager.get(cacheKey);
      if (cached) {
        console.log('[DataManager] 宠物列表命中缓存，数据长度:', cached.length);
        return cached;
      } else {
        console.log('[DataManager] 宠物列表缓存未命中');
      }
    }

    // 防止重复请求
    if (this.loadingPromises.has(cacheKey)) {
      console.log('[DataManager] 发现正在进行的请求，等待结果');
      return this.loadingPromises.get(cacheKey);
    }

    console.log('[DataManager] 开始从服务器加载宠物列表');
    const loadPromise = this._loadPetList(forceRefresh);
    this.loadingPromises.set(cacheKey, loadPromise);

    try {
      const result = await loadPromise;
      if (result) {
        console.log('[DataManager] 宠物列表加载成功，设置缓存，数据长度:', result.length);
        cacheManager.set(cacheKey, result, config.ttl);
      }
      return result;
    } finally {
      this.loadingPromises.delete(cacheKey);
    }
  }

  /**
   * 获取优惠券列表
   * @param {Object} params 查询参数 {status, page, size}
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Object>} 优惠券列表
   */
  async getCouponList(params = {}, forceRefresh = false) {
    const config = this.cacheConfig.couponList;
    const cacheKey = this._getUserCacheKey(`${config.key}_${JSON.stringify(params)}`);
    
    // 检查缓存
    if (!forceRefresh) {
      const cached = cacheManager.get(cacheKey);
      if (cached) {
        console.log('[DataManager] 优惠券列表命中缓存');
        return cached;
      }
    }

    // 防止重复请求
    if (this.loadingPromises.has(cacheKey)) {
      return this.loadingPromises.get(cacheKey);
    }

    const loadPromise = this._loadCouponList(params);
    this.loadingPromises.set(cacheKey, loadPromise);

    try {
      const result = await loadPromise;
      if (result) {
        cacheManager.set(cacheKey, result, config.ttl);
      }
      return result;
    } finally {
      this.loadingPromises.delete(cacheKey);
    }
  }

  /**
   * 获取用户余额
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<number>} 用户余额
   */
  async getUserBalance(forceRefresh = false) {
    const config = this.cacheConfig.userBalance;
    const cacheKey = this._getUserCacheKey(config.key);
    
    // 检查缓存
    if (!forceRefresh) {
      const cached = cacheManager.get(cacheKey);
      if (cached !== null && cached !== undefined) {
        console.log('[DataManager] 用户余额命中缓存');
        return cached;
      }
    }

    // 防止重复请求
    if (this.loadingPromises.has(cacheKey)) {
      return this.loadingPromises.get(cacheKey);
    }

    const loadPromise = this._loadUserBalance();
    this.loadingPromises.set(cacheKey, loadPromise);

    try {
      const result = await loadPromise;
      if (result !== null && result !== undefined) {
        cacheManager.set(cacheKey, result, config.ttl);
      }
      return result;
    } finally {
      this.loadingPromises.delete(cacheKey);
    }
  }

  /**
   * 获取交易记录
   * @param {Object} params 查询参数
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Array>} 交易记录
   */
  async getTradingRecords(params = {}, forceRefresh = false) {
    const config = this.cacheConfig.tradingRecords;
    const cacheKey = this._getUserCacheKey(`${config.key}_${JSON.stringify(params)}`);
    
    // 检查缓存
    if (!forceRefresh) {
      const cached = cacheManager.get(cacheKey);
      if (cached) {
        console.log('[DataManager] 交易记录命中缓存');
        return cached;
      }
    }

    // 防止重复请求
    if (this.loadingPromises.has(cacheKey)) {
      return this.loadingPromises.get(cacheKey);
    }

    const loadPromise = this._loadTradingRecords(params);
    this.loadingPromises.set(cacheKey, loadPromise);

    try {
      const result = await loadPromise;
      if (result) {
        cacheManager.set(cacheKey, result, config.ttl);
      }
      return result;
    } finally {
      this.loadingPromises.delete(cacheKey);
    }
  }

  /**
   * 刷新用户相关的所有缓存
   */
  async refreshUserData() {
    console.log('[DataManager] 刷新用户相关缓存');
    const userId = wx.getStorageSync('userId');
    if (!userId) return;

    // 清除用户相关缓存
    this.invalidateUserCache();

    // 重新加载关键数据
    const promises = [
      this.getUserProfile(true),
      this.getUserBalance(true),
      this.getPetList(true)
    ];

    try {
      await Promise.all(promises);
      console.log('[DataManager] 用户数据刷新完成');
    } catch (error) {
      console.error('[DataManager] 用户数据刷新失败:', error);
    }
  }

  /**
   * 使用户缓存失效
   */
  invalidateUserCache() {
    const userId = wx.getStorageSync('userId');
    if (!userId) return;

    Object.values(this.cacheConfig).forEach(config => {
      const cacheKey = `${config.key}_${userId}`;
      cacheManager.delete(cacheKey);
      // 删除带参数的缓存键
      const allKeys = Array.from(cacheManager.cache.keys());
      allKeys.forEach(key => {
        if (key.startsWith(cacheKey)) {
          cacheManager.delete(key);
        }
      });
    });

    console.log('[DataManager] 用户缓存已失效');
  }

  /**
   * 更新特定数据的缓存
   * @param {string} dataType 数据类型
   * @param {any} newData 新数据
   * @param {Object} params 参数（用于列表类数据）
   */
  updateCache(dataType, newData, params = {}) {
    const config = this.cacheConfig[dataType];
    if (!config) {
      console.warn(`[DataManager] 未知的数据类型: ${dataType}`);
      return;
    }

    let cacheKey;
    if (Object.keys(params).length > 0) {
      cacheKey = this._getUserCacheKey(`${config.key}_${JSON.stringify(params)}`);
    } else {
      cacheKey = this._getUserCacheKey(config.key);
    }

    cacheManager.set(cacheKey, newData, config.ttl);
    console.log(`[DataManager] 更新缓存: ${dataType}`);
  }

  /**
   * 获取缓存状态
   */
  getCacheStatus() {
    const userId = wx.getStorageSync('userId');
    const status = {
      userId,
      cacheItems: {},
      totalCached: 0
    };

    if (userId) {
      Object.entries(this.cacheConfig).forEach(([type, config]) => {
        const cacheKey = `${config.key}_${userId}`;
        const hasCache = cacheManager.has(cacheKey);
        status.cacheItems[type] = {
          cached: hasCache,
          key: cacheKey
        };
        if (hasCache) status.totalCached++;
      });
    }

    return status;
  }

  /**
   * 清除所有用户缓存
   */
  clearAllCache() {
    this.invalidateUserCache();
    this.loadingPromises.clear();
    console.log('[DataManager] 所有缓存已清除');
  }

  // ==================== 私有方法 ====================

  /**
   * 生成用户相关的缓存键
   * @param {string} baseKey 基础键名
   * @returns {string} 完整的缓存键
   */
  _getUserCacheKey(baseKey) {
    const userId = wx.getStorageSync('userId');
    return userId ? `${baseKey}_${userId}` : baseKey;
  }

  /**
   * 加载用户信息
   * @returns {Promise<Object>} 用户信息
   */
  async _loadUserProfile() {
    try {
      console.log('[DataManager] 加载用户信息');
      const result = await apiService.getUserDetail();
      if (result.success && result.data) {
        return result.data;
      }
      throw new Error(result.message || '获取用户信息失败');
    } catch (error) {
      console.error('[DataManager] 加载用户信息失败:', error);
      return null;
    }
  }

  /**
   * 加载订单列表
   * @param {Object} params 查询参数 {status, page, size}
   * @returns {Promise<Object>} 订单列表
   */
  async _loadOrderList(params) {
    try {
      console.log('[DataManager] 加载订单列表:', params);
      // 正确提取参数：status必须是数字或null，不能是布尔值
      const status = params && typeof params.status === 'number' ? params.status : (params && params.status === null ? null : null);
      const page = params && params.page ? parseInt(params.page, 10) : 1;
      const size = params && params.size ? parseInt(params.size, 10) : 20;
      
      const result = await apiService.getMyAppointments(status, page, size);
      if (result.success && result.data) {
        return result.data;
      }
      throw new Error(result.message || '获取订单列表失败');
    } catch (error) {
      console.error('[DataManager] 加载订单列表失败:', error);
      return null;
    }
  }

  /**
   * 加载宠物列表
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Array>} 宠物列表
   */
  async _loadPetList(forceRefresh = false) {
    try {
      console.log('[DataManager] 加载宠物列表, forceRefresh:', forceRefresh);
      const result = await apiService.getPetList(forceRefresh);
      if (result.success && result.data) {
        return result.data;
      }
      throw new Error(result.message || '获取宠物列表失败');
    } catch (error) {
      console.error('[DataManager] 加载宠物列表失败:', error);
      return [];
    }
  }

  /**
   * 加载优惠券列表
   * @param {Object} params 查询参数
   * @returns {Promise<Object>} 优惠券列表
   */
  async _loadCouponList(params) {
    try {
      console.log('[DataManager] 加载优惠券列表:', params);
      const result = await apiService.getCouponList(params);
      if (result.success && result.data) {
        return result.data;
      }
      throw new Error(result.message || '获取优惠券列表失败');
    } catch (error) {
      console.error('[DataManager] 加载优惠券列表失败:', error);
      return null;
    }
  }

  /**
   * 加载用户余额
   * @returns {Promise<number>} 用户余额
   */
  async _loadUserBalance() {
    try {
      console.log('[DataManager] 加载用户余额');
      const userProfile = await this._loadUserProfile();
      if (userProfile && userProfile.balance !== undefined) {
        return parseFloat(userProfile.balance) || 0;
      }
      return 0;
    } catch (error) {
      console.error('[DataManager] 加载用户余额失败:', error);
      return 0;
    }
  }

  /**
   * 加载交易记录
   * @param {Object} params 查询参数
   * @returns {Promise<Array>} 交易记录
   */
  async _loadTradingRecords(params) {
    try {
      console.log('[DataManager] 加载交易记录:', params);
      const result = await apiService.getTradingRecords(params);
      if (result.success && result.data) {
        return result.data;
      }
      throw new Error(result.message || '获取交易记录失败');
    } catch (error) {
      console.error('[DataManager] 加载交易记录失败:', error);
      return [];
    }
  }
}

// 创建全局实例
const dataManager = new DataManager();

module.exports = dataManager;